package service

import (
	"context"
	"fmt"
	"software/global"
	"software/models"
	"software/models/Response"
	"software/models/mongo"
	"sort"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
	"gorm.io/gorm"
)

// GetCommentList 获取评论列表
// 参数:
// - ctx: 上下文
// - postID: 帖子ID
// - page: 页码，从1开始
// - pageSize: 每页数量
// - status: 状态过滤，-1表示不过滤
// - keyword: 关键词搜索
// 返回:
// - CommentListResponse: 评论列表响应
// - error: 错误信息
func GetCommentList(ctx context.Context, postID primitive.ObjectID, page, pageSize int, status int8, keyword string) (Response.CommentListResponse, error) {
	global.Log.Infof("开始获取评论列表，帖子ID：%s，页码：%d，每页数量：%d，状态：%d，关键词：%s",
		postID.Hex(), page, pageSize, status, keyword)

	// 获取MongoDB集合
	collection := global.MongoDBC.Collection(mongo.Comment{}.CollectionName())

	// 构建过滤条件
	filter := bson.M{"post_id": postID}

	// 添加状态过滤
	if status >= 0 {
		filter["status"] = status
	} else {
		// 默认不返回已删除（状态为3）的评论
		filter["status"] = bson.M{"$ne": int8(3)}
	}

	// 添加关键词搜索
	if keyword != "" {
		filter["content"] = bson.M{"$regex": keyword, "$options": "i"}
	}

	// 获取总记录数
	total, err := collection.CountDocuments(ctx, filter)
	if err != nil {
		global.Log.Errorf("统计评论总数失败: %v", err)
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, fmt.Errorf("统计评论总数失败: %v", err)
	}

	// 设置分页
	skip := int64((page - 1) * pageSize)
	limit := int64(pageSize)

	// 查询评论
	findOptions := options.Find().
		SetSkip(skip).
		SetLimit(limit).
		SetSort(bson.D{{Key: "create_time", Value: -1}}) // 按创建时间降序排序

	cursor, err := collection.Find(ctx, filter, findOptions)
	if err != nil {
		global.Log.Errorf("查询评论失败: %v", err)
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, fmt.Errorf("查询评论失败: %v", err)
	}
	defer cursor.Close(ctx)

	// 查询结果
	var comments []mongo.Comment
	if err = cursor.All(ctx, &comments); err != nil {
		global.Log.Errorf("解析评论数据失败: %v", err)
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, fmt.Errorf("解析评论数据失败: %v", err)
	}

	global.Log.Infof("查询到 %d 条评论", len(comments))

	// 如果没有查询到评论，直接返回空列表
	if len(comments) == 0 {
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, nil
	}

	// 提取所有用户ID
	var userIDs []uint64
	for _, comment := range comments {
		userIDs = append(userIDs, comment.UserID)
	}

	// 查询用户信息
	var users []models.User
	if err := global.DB.Where("id IN ?", userIDs).Find(&users).Error; err != nil {
		global.Log.Errorf("查询用户信息失败: %v", err)
		if err != gorm.ErrRecordNotFound {
			return Response.CommentListResponse{
				Total:    0,
				Page:     page,
				PageSize: pageSize,
				List:     []Response.CommentResponse{},
			}, fmt.Errorf("查询用户信息失败: %v", err)
		}
	}

	// 构建用户ID到用户信息的映射
	userMap := make(map[uint64]*models.User)
	for i := range users {
		userMap[users[i].ID] = &users[i]
	}

	// 构建评论响应列表
	var commentResponses []Response.CommentResponse
	for _, comment := range comments {
		user, ok := userMap[comment.UserID]
		if !ok {
			// 如果找不到用户信息，创建一个默认用户
			user = &models.User{
				ID:       comment.UserID,
				Nickname: "未知用户",
				Avatar:   "",
			}
		}
		commentResponses = append(commentResponses, Response.BuildCommentResponse(&comment, user))
	}

	// 返回评论列表响应
	return Response.BuildCommentListResponse(commentResponses, total, page, pageSize), nil
}

// GetCommentByID 根据ID获取评论
func GetCommentByID(ctx context.Context, commentID primitive.ObjectID) (*mongo.Comment, error) {
	// 获取MongoDB集合
	collection := global.MongoDBC.Collection(mongo.Comment{}.CollectionName())

	// 构建查询条件，排除已删除的评论
	filter := bson.M{
		"_id":    commentID,
		"status": bson.M{"$ne": int8(3)},
	}

	// 执行查询
	var comment mongo.Comment
	err := collection.FindOne(ctx, filter).Decode(&comment)
	if err != nil {
		global.Log.Errorf("查询评论失败: %v", err)
		return nil, fmt.Errorf("评论不存在")
	}

	return &comment, nil
}

// GetAllComments 获取所有评论（不分页，慎用）
func GetAllComments(ctx context.Context) ([]mongo.Comment, error) {
	// 获取MongoDB集合
	collection := global.MongoDBC.Collection(mongo.Comment{}.CollectionName())

	// 查询所有评论，排除已删除的评论
	filter := bson.M{"status": bson.M{"$ne": int8(3)}}
	cursor, err := collection.Find(ctx, filter)
	if err != nil {
		global.Log.Errorf("查询所有评论失败: %v", err)
		return nil, fmt.Errorf("查询所有评论失败: %v", err)
	}
	defer cursor.Close(ctx)

	// 查询结果
	var comments []mongo.Comment
	if err = cursor.All(ctx, &comments); err != nil {
		global.Log.Errorf("解析所有评论数据失败: %v", err)
		return nil, fmt.Errorf("解析所有评论数据失败: %v", err)
	}

	// 按创建时间排序
	sort.Slice(comments, func(i, j int) bool {
		return comments[i].CreateTime.After(comments[j].CreateTime)
	})

	return comments, nil
}

// GetCommentsByUserID 获取用户的所有评论
func GetCommentsByUserID(ctx context.Context, userID uint64) ([]mongo.Comment, error) {
	// 获取MongoDB集合
	collection := global.MongoDBC.Collection(mongo.Comment{}.CollectionName())

	// 构建查询条件，排除已删除的评论
	filter := bson.M{
		"user_id": userID,
		"status":  bson.M{"$ne": int8(3)},
	}

	// 查询用户的评论
	cursor, err := collection.Find(ctx, filter, options.Find().SetSort(bson.D{{Key: "create_time", Value: -1}}))
	if err != nil {
		global.Log.Errorf("查询用户评论失败: %v", err)
		return nil, fmt.Errorf("查询用户评论失败: %v", err)
	}
	defer cursor.Close(ctx)

	// 查询结果
	var comments []mongo.Comment
	if err = cursor.All(ctx, &comments); err != nil {
		global.Log.Errorf("解析用户评论数据失败: %v", err)
		return nil, fmt.Errorf("解析用户评论数据失败: %v", err)
	}

	return comments, nil
}

// 辅助函数：从bson.M中获取字符串值
func getStringValue(doc bson.M, key string, defaultValue string) string {
	if val, ok := doc[key]; ok {
		if strVal, ok := val.(string); ok {
			return strVal
		}
	}
	return defaultValue
}

// 辅助函数：从bson.M中获取int32值
func getInt32Value(doc bson.M, key string, defaultValue int32) int32 {
	if val, ok := doc[key]; ok {
		switch v := val.(type) {
		case int32:
			return v
		case int:
			return int32(v)
		case int64:
			return int32(v)
		case float64:
			return int32(v)
		}
	}
	return defaultValue
}

// 辅助函数：从bson.M中获取时间值
func getTimeValue(doc bson.M, key string, defaultValue time.Time) time.Time {
	if val, ok := doc[key]; ok {
		if timeVal, ok := val.(time.Time); ok {
			return timeVal
		}
	}
	return defaultValue
}

// GetAllCommentsPaginated 获取所有评论（分页）
func GetAllCommentsPaginated(ctx context.Context, page, pageSize int, status int8, keyword string) (Response.CommentListResponse, error) {
	global.Log.Infof("开始获取所有评论列表，页码：%d，每页数量：%d，状态：%d，关键词：%s",
		page, pageSize, status, keyword)

	// 获取MongoDB集合
	collection := global.MongoDBC.Collection(mongo.Comment{}.CollectionName())

	// 构建过滤条件
	filter := bson.M{}

	// 添加状态过滤
	if status >= 0 {
		filter["status"] = status
	} else {
		// 默认不返回已删除（状态为3）的评论
		filter["status"] = bson.M{"$ne": int8(3)}
	}

	// 添加关键词搜索
	if keyword != "" {
		filter["content"] = bson.M{"$regex": keyword, "$options": "i"}
	}

	// 获取总记录数
	total, err := collection.CountDocuments(ctx, filter)
	if err != nil {
		global.Log.Errorf("统计评论总数失败: %v", err)
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, fmt.Errorf("统计评论总数失败: %v", err)
	}

	// 设置分页
	skip := int64((page - 1) * pageSize)
	limit := int64(pageSize)

	// 查询评论
	findOptions := options.Find().
		SetSkip(skip).
		SetLimit(limit).
		SetSort(bson.D{{Key: "create_time", Value: -1}}) // 按创建时间降序排序

	cursor, err := collection.Find(ctx, filter, findOptions)
	if err != nil {
		global.Log.Errorf("查询评论失败: %v", err)
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, fmt.Errorf("查询评论失败: %v", err)
	}
	defer cursor.Close(ctx)

	// 查询结果
	var comments []mongo.Comment
	if err = cursor.All(ctx, &comments); err != nil {
		global.Log.Errorf("解析评论数据失败: %v", err)
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, fmt.Errorf("解析评论数据失败: %v", err)
	}

	global.Log.Infof("查询到 %d 条评论", len(comments))

	// 如果没有查询到评论，直接返回空列表
	if len(comments) == 0 {
		return Response.CommentListResponse{
			Total:    0,
			Page:     page,
			PageSize: pageSize,
			List:     []Response.CommentResponse{},
		}, nil
	}

	// 提取所有用户ID
	var userIDs []uint64
	for _, comment := range comments {
		userIDs = append(userIDs, comment.UserID)
	}

	// 查询用户信息
	var users []models.User
	if err := global.DB.Where("id IN ?", userIDs).Find(&users).Error; err != nil {
		global.Log.Errorf("查询用户信息失败: %v", err)
		if err != gorm.ErrRecordNotFound {
			return Response.CommentListResponse{
				Total:    0,
				Page:     page,
				PageSize: pageSize,
				List:     []Response.CommentResponse{},
			}, fmt.Errorf("查询用户信息失败: %v", err)
		}
	}

	// 构建用户ID到用户信息的映射
	userMap := make(map[uint64]*models.User)
	for i := range users {
		userMap[users[i].ID] = &users[i]
	}

	// 构建评论响应列表
	var commentResponses []Response.CommentResponse
	for _, comment := range comments {
		user, ok := userMap[comment.UserID]
		if !ok {
			// 如果找不到用户信息，创建一个默认用户
			user = &models.User{
				ID:       comment.UserID,
				Nickname: "未知用户",
				Avatar:   "",
			}
		}
		commentResponses = append(commentResponses, Response.BuildCommentResponse(&comment, user))
	}

	// 返回评论列表响应
	return Response.BuildCommentListResponse(commentResponses, total, page, pageSize), nil
}

// DeleteComment 软删除评论（将状态设置为3）
func DeleteComment(ctx context.Context, commentID primitive.ObjectID) error {
	global.Log.Infof("软删除评论，ID: %s", commentID.Hex())

	// 调用UpdateCommentStatus将评论状态设置为3（已删除）
	err := UpdateCommentStatus(ctx, commentID, 3)
	if err != nil {
		global.Log.Errorf("软删除评论失败: %v", err)
		return fmt.Errorf("软删除评论失败: %v", err)
	}

	global.Log.Infof("评论软删除成功，ID: %s", commentID.Hex())
	return nil
}

// GetLatestCommentsWithoutPagination 获取最新评论（不分页）
func GetLatestCommentsWithoutPagination(ctx context.Context, limit int) ([]Response.CommentResponse, error) {
	global.Log.Infof("开始获取最新评论（不分页），数量限制：%d", limit)

	// 获取MongoDB集合
	collection := global.MongoDBC.Collection(mongo.Comment{}.CollectionName())

	// 构建过滤条件，包含所有非删除状态的评论
	filter := bson.M{"status": bson.M{"$ne": int8(3)}} // 排除已删除的评论（状态为3）

	// 设置查询选项
	findOptions := options.Find().
		SetLimit(int64(limit)).
		SetSort(bson.D{{Key: "create_time", Value: -1}}) // 按创建时间降序排序

	// 执行查询
	cursor, err := collection.Find(ctx, filter, findOptions)
	if err != nil {
		global.Log.Errorf("查询最新评论失败: %v", err)
		return []Response.CommentResponse{}, fmt.Errorf("查询最新评论失败: %v", err)
	}
	defer cursor.Close(ctx)

	// 查询结果
	var comments []mongo.Comment
	if err = cursor.All(ctx, &comments); err != nil {
		global.Log.Errorf("解析评论数据失败: %v", err)
		return []Response.CommentResponse{}, fmt.Errorf("解析评论数据失败: %v", err)
	}

	global.Log.Infof("查询到 %d 条最新评论", len(comments))

	// 如果没有查询到评论，直接返回空列表
	if len(comments) == 0 {
		return []Response.CommentResponse{}, nil
	}

	// 提取所有用户ID
	var userIDs []uint64
	for _, comment := range comments {
		userIDs = append(userIDs, comment.UserID)
	}

	// 查询用户信息
	var users []models.User
	if err := global.DB.Where("id IN ?", userIDs).Find(&users).Error; err != nil {
		global.Log.Errorf("查询用户信息失败: %v", err)
		if err != gorm.ErrRecordNotFound {
			return []Response.CommentResponse{}, fmt.Errorf("查询用户信息失败: %v", err)
		}
	}

	// 构建用户ID到用户信息的映射
	userMap := make(map[uint64]*models.User)
	for i := range users {
		userMap[users[i].ID] = &users[i]
	}

	// 构建评论响应列表
	var commentResponses []Response.CommentResponse
	for _, comment := range comments {
		user, ok := userMap[comment.UserID]
		if !ok {
			// 如果找不到用户信息，创建一个默认用户
			user = &models.User{
				ID:       comment.UserID,
				Nickname: "未知用户",
				Avatar:   "",
			}
		}
		commentResponses = append(commentResponses, Response.BuildCommentResponse(&comment, user))
	}

	return commentResponses, nil
}
